package com.aynu.gulimall.search.thread;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author mj
 * @version 1.0
 * @date 2021/3/13 12:01
 */
public class ThreadTest {

    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
    ;

    /**
     * Future:可以获取到异步结果
     * CompletableFuture:异步编排
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("开始");
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getName());
//            int i = 10 / 2;
//            System.out.println("计算结果：" + i);
//        }, executorService);



        //当这个线程执行完任务后，回调方法,【方法完成后的感知】
//        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getName());
//            int i = 10 / 0;
//            System.out.println("计算结果：" + i);
//            return i;
//        }, executorService).whenComplete((result,exception)->{
//            //result:执行完成后的结果
//            //exception:出现的异常（虽然能得到异常信息，但是没办法修改返回数据信息，
//            // 【不是修改这里的数据，是修改completableFuture的返回数据,否则获取值的时候会报异常】）
//            System.out.println("异步任务成功完成。。。");
//            System.out.println("结果："+result);
//            System.out.println("异常："+exception);
//        }).exceptionally(throwable -> {
//            //throwable:异常，比如：出现异常后的处理,进行默认处理
//            //可以感知异常，并进行处理
//            return 10;
//        });


        //方法完成后的处理
//        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getName());
//            int i = 10 / 4;
//            System.out.println("计算结果：" + i);
//            return i;
//        }, executorService).handle((result,exception)->{
//            if (result!=null){
//                return result * 2;
//            }
//            if (exception!=null){
//                return 0;
//            }
//            return 0;
//        });


        //线程串行化：
        /**
         * Async：后面有这个的，表示开启一个新线程执行，使用自定义的线程池，没有则表示还是用原来的线程
         * 1）、thenRunAsync:不能获取上一步执行的结果
         *  thenRunAsync(() -> {
         *             System.out.println("任务2执行。。。");
         *         }, executorService)
         * 2）、thenAcceptAsync:能获取上一步执行的结果，但是无返回值
         *  thenAcceptAsync((result) -> {
         *             System.out.println("任务2执行。。。"+result);
         *         }, executorService)
         * 3）、能获取上一步执行的结果，有返回值
         */
//        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getName());
//            int i = 10 / 4;
//            System.out.println("计算结果：" + i);
//            return i;
//        }, executorService).thenApplyAsync((result) -> {
//            System.out.println("任务2执行。。。" + result);
//            return result + "world";
//        }, executorService);


        /**
         * 1、runAfterBothAsync：不能感知到前两个的执行结果，没有返回值
         * 2、thenAcceptBothAsync：能感知到前两个的执行结果，没有返回值
         */
        //三个任务，当两个任务都完成时，任务3才执行
//        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("任务一");
//            System.out.println("当前线程：" + Thread.currentThread().getName());
//            int i = 10 / 4;
//            System.out.println("计算结果：" + i);
//            return i;
//        }, executorService);
//
//        CompletableFuture<Integer> future02 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("任务二");
//            System.out.println("当前线程：" + Thread.currentThread().getName());
//            int i = 10 / 2;
//            System.out.println("计算结果：" + i);
//            try {
//                Thread.sleep(3000L);
//                System.out.println("任务二结束");
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            return i;
//        }, executorService);

//        future01.thenAcceptBothAsync(future02,(f1,f2)->{
//            System.out.println(f1+"==="+f2);
//            System.out.println("任务三");
//        },executorService);

//        future01.runAfterBothAsync(future02,()->{
//            System.out.println("任务三");
//        },executorService);

//        CompletableFuture<String> 任务三 = future01.thenCombineAsync(future02, (f1, f2) -> {
//            System.out.println(f1 + "<---->" + f2);
//            System.out.println("任务三");
//            return f1 + "<---->" + f2;
//        }, executorService);
//        System.out.println("执行结果："+任务三.get());

        /**
         * 1）、runAfterEitherAsync:不感知结果，也没有返回值
         * 2）、acceptEitherAsync：感知结果，也没有返回值
         * 3）、applyToEitherAsync：感知结果，有返回值
         */
        //三个任务，其中两个任务只要有一个执行完成，就执行任务三
//        future01.runAfterEitherAsync(future02,()->{
//            System.out.println("任务三");
//        },executorService);

//        future01.acceptEitherAsync(future02,(result)->{
//            System.out.println("任务三"+result);
//        },executorService);

//        CompletableFuture<String> future = future01.applyToEitherAsync(future02, (result) -> {
//            System.out.println("任务三" + result);
//            return "->>" + result;
//        }, executorService);


        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的图片信息");
            return "img";
        },executorService);

        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的属性信息");
            return "attr";
        },executorService);

        CompletableFuture<String> futureBase = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000L);
                System.out.println("查询商品的基本信息");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "base";
        },executorService);

//        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureBase);
        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureBase);
        //等待所有结果完成
        anyOf.get();


        //get是一个阻塞方法，直到获取值
        System.out.println("结束"+anyOf.get());
    }
}
